package model

import (
	"errors"
	"fmt"
	"gorm.io/gorm"
	"runtime/debug"
	"time"
)

type SmFtpInfo struct {
	Id                int64  `json:"id" gorm:"id"`
	UserId            int64  `json:"user_id" gorm:"user_id"`
	FtpType           string `json:"ftp_type" gorm:"ftp_type"`                       // ftp类型
	FtpUserName       string `json:"ftp_user_name" gorm:"ftp_user_name"`             // 账号
	FtpPassword       string `json:"ftp_password" gorm:"ftp_password"`               // 密码
	FtpAddress        string `json:"ftp_address" gorm:"ftp_address"`                 // 地址
	Port              string `json:"port" gorm:"port"`                               // 端口
	UserConnectStatus int64  `json:"user_connect_status" gorm:"user_connect_status"` // 用户连接状态  0:关闭；1:连接
	WokerStatus       int64  `json:"woker_status" gorm:"woker_status"`               // 服务启动状态0：未启动；1 已启动；
	EventStatus       int64  `json:"event_status" gorm:"event_status"`               // 事件执行状态  0：未启动；1 已启动；
	FtpConnectStatus  int64  `json:"ftp_connect_status" gorm:"ftp_connect_status"`   // ftp连接状态   0：关闭； 1：连接成功；2：连接中； 3:关闭中
	FtpInfo           string `json:"ftp_info" gorm:"ftp_info"`                       // ftp连接结果
	DataUpdatedAt     int64  `json:"data_updated_at" gorm:"data_updated_at"`         // 数据更新时间
	UUpdatedAt        int64  `json:"u_updated_at" gorm:"u_updated_at"`               // 用户更新时间
	UpdatedAt         int64  `json:"updated_at" gorm:"updated_at"`                   // 数据更新时间
	CreatedAt         int64  `json:"created_at" gorm:"created_at"`                   // 添加时间
}

func (SmFtpInfo) TableName() string {
	return "sm_ftp_info"
}

type FtpInfo struct {
	DB        *gorm.DB
	SmFtpInfo SmFtpInfo
}

func NewFtpInfo() *FtpInfo {
	return &FtpInfo{
		GetDB(),
		SmFtpInfo{},
		//Inject services
	}
}

func (f FtpInfo) GetFtpInfo() []SmFtpInfo {
	var info = []SmFtpInfo{}
	result := f.DB.Not(&SmFtpInfo{FtpType: "ZJ"}).Find(&info)
	if result.Error != nil {
		panic(result.Error)
	}
	//fmt.Print("条数", result.RowsAffected)
	//fmt.Print(info)
	return info
}

// 修改woker状态
func (f *FtpInfo) SetWokerStatus(id int64, status int64) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"woker_status": status})

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	//fmt.Print("条数", result.RowsAffected)

	return true
}

// 修改FTP连接状态
func (f *FtpInfo) UpdateFtpStatus(id int64, status int64) bool {

	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	var data map[string]interface{}
	if status == 1 {
		data = map[string]interface{}{"ftp_connect_status": status, "ftp_info": "连接成功"}
	} else {
		data = map[string]interface{}{"ftp_connect_status": status}
	}
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(data)

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	//fmt.Print("条数", result.RowsAffected)

	return true
}

// 修改FTP连接状态与信息
func (f *FtpInfo) UpdateFtpInfo(id int64, status int64, err string) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"ftp_connect_status": status, "ftp_info": err})

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	//fmt.Print("条数", result.RowsAffected)

	return true
}

// 主动关闭Ftp连接状态
func (f *FtpInfo) CloseFtpConnectStatus(id int64, status int64) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"ftp_connect_status": status})

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	//fmt.Print("条数", result.RowsAffected)

	return true
}

// 修改事件执行状态
func (f *FtpInfo) UpdateEventStatus(id int64, status int64) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	//fmt.Println("心跳时间", unixTime)
	result := f.DB.Model(&SmFtpInfo{}).Where("id = ?", id).Updates(map[string]interface{}{"event_status": status})

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	return true
}

// 数据保存时间
func (f *FtpInfo) SaveDataUpdatedTime(id int64) bool {
	now := time.Now()
	unixTime := now.Unix()

	result := f.DB.Model(&SmFtpInfo{}).Where("id = ?", id).Updates(map[string]interface{}{"data_updated_at": unixTime})
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	return true
}

// 第一次连接失败关闭连接
func (f *FtpInfo) CloseUserConnect(id int64) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"UserConnectStatus": 0})

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	//fmt.Print("条数", result.RowsAffected)

	return true
}

// 修改FTP连接状态与信息
func (f *FtpInfo) UpdateFtpErr(id int64, err string) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"ftp_info": err})

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	//fmt.Print("条数", result.RowsAffected)

	return true
}

// 关闭连接
func (f *FtpInfo) CloseFtpConnect(id int64, desc string) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"user_connect_status": 0, "woker_status": 0, "event_status": 0, "ftp_connect_status": 0, "ftp_info": desc})
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	return true
}

// 重新连接
func (f *FtpInfo) ReStartFtpConnect(id int64, desc string) bool {
	defer func() {
		if r := recover(); r != nil {

			fmt.Println("查询错误", r)
			fmt.Println("查询错误", string(debug.Stack()))

		}
	}()
	result := f.DB.Model(&SmFtpInfo{}).Where(&SmFtpInfo{Id: id}).Updates(map[string]interface{}{"woker_status": 0, "event_status": 0, "ftp_connect_status": 0, "ftp_info": desc})
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 没有找到记录
			return false
		} else {
			panic(result.Error)
			// 真正的执行错误

		}
	}
	return true
}
